Lambda

Les expressions lambda ont été introduites en Java 8 pour écrire du code plus concis et expressif. Elles permettent de définir des fonctions anonymes directement dans une méthode, ce qui est particulièrement utile pour gérer des événements ou manipuler des collections.

Syntaxe de base

Une expression lambda suit cette structure :

(paramètre) -> expression

Un paramètre — gestionnaire d'événement

Avant Java 8, brancher un bouton nécessitait une classe anonyme :

btn.setOnAction(new EventHandler<ActionEvent>() {
    @Override
    public void handle(ActionEvent event) {
        System.out.println("Bouton cliqué !");
    }
});

Avec une lambda, c'est la même chose en une ligne :

btn.setOnAction(event -> System.out.println("Bouton cliqué !"));

event est le paramètre reçu (le ActionEvent). La lambda remplace entièrement la classe anonyme.

---

Plusieurs instructions — lambda avec bloc { }

Quand la lambda fait plus d'une chose, on utilise { } et return si nécessaire :

btn.setOnAction(event -> {
    label.setText("Formulaire envoyé !");
    btn.setDisable(true);
});

Sans { }, Java ne peut accepter qu'une seule expression. Dès qu'on en a deux, les accolades sont obligatoires.

2. Restrictions

• Si une lambda ne contient qu’une seule instruction, {} et return ne sont pas nécessaires.
• Si elle contient plusieurs instructions, elles doivent être encadrées par {}, et return est obligatoire si une valeur doit être retournée.
• Une lambda peut accéder aux variables locales de la méthode qui l’entoure, mais ces variables doivent être final ou effectivement finales (non modifiées après leur déclaration).

String message = "Bonjour ";   // effectivement final — jamais réassigné

btn.setOnAction(event -> System.out.println(message + "monde !"));  // OK

String message = "Bonjour ";
message = "Salut ";             // réassigné — plus effectivement final

btn.setOnAction(event -> System.out.println(message)); // ERREUR de compilation

La raison : une lambda peut s’exécuter après la fin de la méthode qui l’a créée. Si la variable pouvait changer entre-temps, la lambda lirait une valeur imprévisible.

3. Exemples d'utilisation

3.1. Utilisation avec forEach

Les expressions lambda sont aussi utiles pour parcourir une liste :

import java.util.ArrayList;

public class LambdaForEach {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(9);
        numbers.add(8);
        numbers.add(1);

        // Affichage de chaque élément
        numbers.forEach(n -> System.out.println(n));

        // Affichage du carré de chaque élément
        numbers.forEach(n -> System.out.println(n * n));
    }
}